#include "tiffiop.h"

void _TIFFSetDefaultCompressionState( TIFF* tif );

static const long typemask[13] = {
  ( long )0L, /* TIFF_NOTYPE */
  ( long )0x000000ffL, /* TIFF_BYTE */
  ( long )0xffffffffL, /* TIFF_ASCII */
  ( long )0x0000ffffL, /* TIFF_SHORT */
  ( long )0xffffffffL, /* TIFF_LONG */
  ( long )0xffffffffL, /* TIFF_RATIONAL */
  ( long )0x000000ffL, /* TIFF_SBYTE */
  ( long )0x000000ffL, /* TIFF_UNDEFINED */
  ( long )0x0000ffffL, /* TIFF_SSHORT */
  ( long )0xffffffffL, /* TIFF_SLONG */
  ( long )0xffffffffL, /* TIFF_SRATIONAL */
  ( long )0xffffffffL, /* TIFF_FLOAT */
  ( long )0xffffffffL, /* TIFF_DOUBLE */
};
static const int bigTypeshift[13] = {
  0,    /* TIFF_NOTYPE */
  24,   /* TIFF_BYTE */
  0,    /* TIFF_ASCII */
  16,   /* TIFF_SHORT */
  0,    /* TIFF_LONG */
  0,    /* TIFF_RATIONAL */
  24,   /* TIFF_SBYTE */
  24,   /* TIFF_UNDEFINED */
  16,   /* TIFF_SSHORT */
  0,    /* TIFF_SLONG */
  0,    /* TIFF_SRATIONAL */
  0,    /* TIFF_FLOAT */
  0,    /* TIFF_DOUBLE */
};
static const int litTypeshift[13] = {
  0,    /* TIFF_NOTYPE */
  0,    /* TIFF_BYTE */
  0,    /* TIFF_ASCII */
  0,    /* TIFF_SHORT */
  0,    /* TIFF_LONG */
  0,    /* TIFF_RATIONAL */
  0,    /* TIFF_SBYTE */
  0,    /* TIFF_UNDEFINED */
  0,    /* TIFF_SSHORT */
  0,    /* TIFF_SLONG */
  0,    /* TIFF_SRATIONAL */
  0,    /* TIFF_FLOAT */
  0,    /* TIFF_DOUBLE */
};

/*
   Initialize the shift & mask tables, and the
   byte swapping state according to the file
   contents and the machine architecture.
*/
static void
TIFFInitOrder( TIFF* tif, int magic, int bigendian ) {
  tif->tif_typemask = typemask;
  if( magic == TIFF_BIGENDIAN ) {
    tif->tif_typeshift = bigTypeshift;
    if( !bigendian ) {
      tif->tif_flags |= TIFF_SWAB;
    }
  } else {
    tif->tif_typeshift = litTypeshift;
    if( bigendian ) {
      tif->tif_flags |= TIFF_SWAB;
    }
  }
}

int
_TIFFgetMode( const char* mode, const char* module ) {
  int m = -1;
  switch( mode[0] ) {
    case 'r':
      m = O_RDONLY;
      if( mode[1] == '+' ) {
        m = O_RDWR;
      }
      break;
    case 'w':
    case 'a':
      m = O_RDWR | O_CREAT;
      if( mode[0] == 'w' ) {
        m |= O_TRUNC;
      }
      break;
    default:
      TIFFError( module, "\"%s\": Bad mode", mode );
      break;
  }
  return ( m );
}

TIFF*
TIFFClientOpen(
  const char* name, const char* mode,
  thandle_t clientdata,
  TIFFReadWriteProc readproc,
  TIFFReadWriteProc writeproc,
  TIFFSeekProc seekproc,
  TIFFCloseProc closeproc,
  TIFFSizeProc sizeproc,
  TIFFMapFileProc mapproc,
  TIFFUnmapFileProc unmapproc
) {
  static const char module[] = "TIFFClientOpen";
  TIFF *tif;
  int m, bigendian;
  const char* cp;
  m = _TIFFgetMode( mode, module );
  if( m == -1 ) {
    goto bad2;
  }
  tif = ( TIFF * )_TIFFmalloc( sizeof( TIFF ) + strlen( name ) + 1 );
  if( tif == NULL ) {
    TIFFError( module, "%s: Out of memory (TIFF structure)", name );
    goto bad2;
  }
  _TIFFmemset( tif, 0, sizeof( *tif ) );
  tif->tif_name = ( char * )tif + sizeof( TIFF );
  strcpy( tif->tif_name, name );
  tif->tif_mode = m & ~( O_CREAT | O_TRUNC );
  tif->tif_curdir = ( tdir_t ) - 1; /* non-existent directory */
  tif->tif_curoff = 0;
  tif->tif_curstrip = ( tstrip_t ) - 1; /* invalid strip */
  tif->tif_row = ( uint32 ) - 1; /* read/write pre-increment */
  tif->tif_clientdata = clientdata;
  if( !readproc || !writeproc || !seekproc || !closeproc
      || !sizeproc || !mapproc || !unmapproc ) {
    TIFFError( module, "One of the client procedures are NULL pointer" );
    goto bad3;
  }
  tif->tif_readproc = readproc;
  tif->tif_writeproc = writeproc;
  tif->tif_seekproc = seekproc;
  tif->tif_closeproc = closeproc;
  tif->tif_sizeproc = sizeproc;
  tif->tif_mapproc = mapproc;
  tif->tif_unmapproc = unmapproc;
  _TIFFSetDefaultCompressionState( tif ); /* setup default state */
  /*
     Default is to return data MSB2LSB and enable the
     use of memory-mapped files and strip chopping when
     a file is opened read-only.
  */
  tif->tif_flags = FILLORDER_MSB2LSB;
  if( m == O_RDONLY ) {
    tif->tif_flags |= TIFF_MAPPED;
  }
  #ifdef STRIPCHOP_DEFAULT
  if( m == O_RDONLY || m == O_RDWR ) {
    tif->tif_flags |= STRIPCHOP_DEFAULT;
  }
  #endif
  { union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; }
  /*
     Process library-specific flags in the open mode string.
     The following flags may be used to control intrinsic library
     behaviour that may or may not be desirable (usually for
     compatibility with some application that claims to support
     TIFF but only supports some braindead idea of what the
     vendor thinks TIFF is):

     'l'    use little-endian byte order for creating a file
     'b'    use big-endian byte order for creating a file
     'L'    read/write information using LSB2MSB bit order
     'B'    read/write information using MSB2LSB bit order
     'H'    read/write information using host bit order
     'M'    enable use of memory-mapped files when supported
     'm'    disable use of memory-mapped files
     'C'    enable strip chopping support when reading
     'c'    disable strip chopping support

     The use of the 'l' and 'b' flags is strongly discouraged.
     These flags are provided solely because numerous vendors,
     typically on the PC, do not correctly support TIFF; they
     only support the Intel little-endian byte order.  This
     support is not configured by default because it supports
     the violation of the TIFF spec that says that readers *MUST
     support both byte orders.  It is strongly recommended that
     you not use this feature except to deal with busted apps
     that write invalid TIFF.  And even in those cases you should
     bang on the vendors to fix their software.

     The 'L', 'B', and 'H' flags are intended for applications
     that can optimize operations on data by using a particular
     bit order.  By default the library returns data in MSB2LSB
     bit order for compatibility with older versions of this
     library.  Returning data in the bit order of the native cpu
     makes the most sense but also requires applications to check
     the value of the FillOrder tag; something they probabyl do
     not do right now.

     The 'M' and 'm' flags are provided because some virtual memory
     systems exhibit poor behaviour when large images are mapped.
     These options permit clients to control the use of memory-mapped
     files on a per-file basis.

     The 'C' and 'c' flags are provided because the library support
     for chopping up large strips into multiple smaller strips is not
     application-transparent and as such can cause problems.  The 'c'
     option permits applications that only want to look at the tags,
     for example, to get the unadulterated TIFF tag information.
  */
  for( cp = mode; *cp; cp++ )
    switch( *cp ) {
      case 'b':
        if( ( m & O_CREAT ) && !bigendian ) {
          tif->tif_flags |= TIFF_SWAB;
        }
        break;
      case 'l':
        if( ( m & O_CREAT ) && bigendian ) {
          tif->tif_flags |= TIFF_SWAB;
        }
        break;
      case 'B':
        tif->tif_flags = ( tif->tif_flags & ~ TIFF_FILLORDER ) |
                         FILLORDER_MSB2LSB;
        break;
      case 'L':
        tif->tif_flags = ( tif->tif_flags & ~ TIFF_FILLORDER ) |
                         FILLORDER_LSB2MSB;
        break;
      case 'H':
        tif->tif_flags = ( tif->tif_flags & ~ TIFF_FILLORDER ) |
                         HOST_FILLORDER;
        break;
      case 'M':
        if( m == O_RDONLY ) {
          tif->tif_flags |= TIFF_MAPPED;
        }
        break;
      case 'm':
        if( m == O_RDONLY ) {
          tif->tif_flags &= ~TIFF_MAPPED;
        }
        break;
      case 'C':
        if( m == O_RDONLY ) {
          tif->tif_flags |= TIFF_STRIPCHOP;
        }
        break;
      case 'c':
        if( m == O_RDONLY ) {
          tif->tif_flags &= ~TIFF_STRIPCHOP;
        }
        break;
    }
  /*
     Read in TIFF header.
  */
  if( !ReadOK( tif, &tif->tif_header, sizeof( TIFFHeader ) ) ) {
    if( tif->tif_mode == O_RDONLY ) {
      TIFFError( name, "Cannot read TIFF header" );
      goto bad;
    }
    /*
       Setup header and write.
    */
    tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
                                 ? ( bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN )
                                 : ( bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN );
    tif->tif_header.tiff_version = TIFF_VERSION;
    if( tif->tif_flags & TIFF_SWAB ) {
      TIFFSwabShort( &tif->tif_header.tiff_version );
    }
    tif->tif_header.tiff_diroff = 0;  /* filled in later */
    /*
       This seek shouldn't be necessary, but I have had some
       crazy problems with a failed fseek() on Solaris leaving
       the current file pointer out of whack when an fwrite()
       is done.
    */
    TIFFSeekFile( tif, 0, SEEK_SET );
    if( !WriteOK( tif, &tif->tif_header, sizeof( TIFFHeader ) ) ) {
      TIFFError( name, "Error writing TIFF header" );
      goto bad;
    }
    /*
       Setup the byte order handling.
    */
    TIFFInitOrder( tif, tif->tif_header.tiff_magic, bigendian );
    /*
       Setup default directory.
    */
    if( !TIFFDefaultDirectory( tif ) ) {
      goto bad;
    }
    tif->tif_diroff = 0;
    tif->tif_dirlist = NULL;
    tif->tif_dirnumber = 0;
    return ( tif );
  }
  /*
     Setup the byte order handling.
  */
  if( tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
      tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN ) {
    TIFFError( name,  "Not a TIFF file, bad magic number %d (0x%x)",
               tif->tif_header.tiff_magic,
               tif->tif_header.tiff_magic );
    goto bad;
  }
  TIFFInitOrder( tif, tif->tif_header.tiff_magic, bigendian );
  /*
     Swap header if required.
  */
  if( tif->tif_flags & TIFF_SWAB ) {
    TIFFSwabShort( &tif->tif_header.tiff_version );
    TIFFSwabLong( &tif->tif_header.tiff_diroff );
  }
  /*
     Now check version (if needed, it's been byte-swapped).
     Note that this isn't actually a version number, it's a
     magic number that doesn't change (stupid).
  */
  if( tif->tif_header.tiff_version != TIFF_VERSION ) {
    TIFFError( name,
               "Not a TIFF file, bad version number %d (0x%x)",
               tif->tif_header.tiff_version,
               tif->tif_header.tiff_version );
    goto bad;
  }
  tif->tif_flags |= TIFF_MYBUFFER;
  tif->tif_rawcp = tif->tif_rawdata = 0;
  tif->tif_rawdatasize = 0;
  /*
     Setup initial directory.
  */
  switch( mode[0] ) {
    case 'r':
      tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
      /*
         Try to use a memory-mapped file if the client
         has not explicitly suppressed usage with the
         'm' flag in the open mode (see above).
      */
      if( ( tif->tif_flags & TIFF_MAPPED ) &&
          !TIFFMapFileContents( tif, ( tdata_t* ) &tif->tif_base, &tif->tif_size ) ) {
        tif->tif_flags &= ~TIFF_MAPPED;
      }
      if( TIFFReadDirectory( tif ) ) {
        tif->tif_rawcc = -1;
        tif->tif_flags |= TIFF_BUFFERSETUP;
        return ( tif );
      }
      break;
    case 'a':
      /*
         New directories are automatically append
         to the end of the directory chain when they
         are written out (see TIFFWriteDirectory).
      */
      if( !TIFFDefaultDirectory( tif ) ) {
        goto bad;
      }
      return ( tif );
  }
bad:
  tif->tif_mode = O_RDONLY; /* XXX avoid flush */
  TIFFClose( tif );
  return ( ( TIFF* )0 );
bad2:
  ( void )( *closeproc )( clientdata );
bad3:
  return ( ( TIFF* )0 );
}

/*
   Query functions to access private data.
*/

/*
   Return open file's name.
*/
const char *
TIFFFileName( TIFF* tif ) {
  return ( tif->tif_name );
}

/*
   Return open file's I/O descriptor.
*/
int
TIFFFileno( TIFF* tif ) {
  return ( tif->tif_fd );
}

/*
   Return read/write mode.
*/
int
TIFFGetMode( TIFF* tif ) {
  return ( tif->tif_mode );
}

/*
   Return nonzero if file is organized in
   tiles; zero if organized as strips.
*/
int
TIFFIsTiled( TIFF* tif ) {
  return ( isTiled( tif ) );
}

/*
   Return current row being read/written.
*/
uint32
TIFFCurrentRow( TIFF* tif ) {
  return ( tif->tif_row );
}

/*
   Return index of the current directory.
*/
tdir_t
TIFFCurrentDirectory( TIFF* tif ) {
  return ( tif->tif_curdir );
}

/*
   Return current strip.
*/
tstrip_t
TIFFCurrentStrip( TIFF* tif ) {
  return ( tif->tif_curstrip );
}

/*
   Return current tile.
*/
ttile_t
TIFFCurrentTile( TIFF* tif ) {
  return ( tif->tif_curtile );
}

/*
   Return nonzero if the file has byte-swapped data.
*/
int
TIFFIsByteSwapped( TIFF* tif ) {
  return ( ( tif->tif_flags & TIFF_SWAB ) != 0 );
}

/*
   Return nonzero if the data is returned up-sampled.
*/
int
TIFFIsUpSampled( TIFF* tif ) {
  return ( isUpSampled( tif ) );
}

/*
   Return nonzero if the data is returned in MSB-to-LSB bit order.
*/
int
TIFFIsMSB2LSB( TIFF* tif ) {
  return ( isFillOrder( tif, FILLORDER_MSB2LSB ) );
}
